//--------格式化数据--------

type TreeData<T> = T & {
    children?: TreeData<T>[]
}
type DataModel = string | number | boolean | null | undefined | Date
/**
 * @description 格式化树形数据
 * @param {T[]} data - 待格式化的数据
 * @param {keyof T} key - 节点的id字段名称
 * @param {keyof T} parentKey - 节点的父节点id字段名称
 * @param {keyof T} labelField - 节点的label字段名称
 * @returns {TreeData<T>[]} - 格式化后的树形数据
 * */
export const formatTreeData = <T extends Record<string, DataModel>>(
    data: T[],
    key: keyof T,
    parentKey: keyof T,
    labelField: keyof T,
): TreeData<T>[] => {
    // 防御性编程：处理非数组和空数组
    if (!Array.isArray(data) || data.length === 0) return []

    // 创建哈希映射表（O(n)时间复杂度）
    const nodeMap = new Map<T[keyof T], TreeData<T>>(
        data.map((item) => {
            return [
                item[key],
                {
                    ...item,
                    label: item[labelField],
                    children: [], // 初始化子节点容器
                },
            ]
        }),
    )

    // 构建树形结构（O(n)时间复杂度）
    const rootNodes: TreeData<T>[] = []
    for (const item of data) {
        const nodeId = item[key]
        const parentId = item[parentKey]
        const currentNode = nodeMap.get(nodeId)

        if (!currentNode) continue

        // 处理父节点存在的情况
        if (parentId && nodeMap.has(parentId)) {
            const parentNode = nodeMap.get(parentId)
            parentNode?.children?.push(currentNode)
        } else if (parentId && !nodeMap.has(parentId)) {
            console.warn(`孤立节点: ${nodeId} (上级 ${parentId} 未找到)`)
        } else {
            // 根节点
            rootNodes.push(currentNode)
        }
    }

    // 递归排序函数（支持无限层级）
    const sortTree = (nodes: TreeData<T>[]): TreeData<T>[] => {
        return nodes
            .sort((a, b) => {
                const aSort = typeof a.sort === 'number' ? a.sort : 0;
                const bSort = typeof b.sort === 'number' ? b.sort : 0;
                return aSort - bSort;
            })
            .map((node) => ({
                ...node,
                children: node.children ? sortTree(node.children) : [],
            }))
    }

    return sortTree(rootNodes)
}
